home *** CD-ROM | disk | FTP | other *** search
/ Revolution - Das Atari CD Magazin 1997 / Revolution - Das Atari CD Magazin 1.iso / software / anwendng / utility / cbhd502 / src / m2 / scsidisk.m < prev    next >
Text File  |  1997-01-21  |  9KB  |  309 lines
  1. IMPLEMENTATION MODULE ScsiDisk;
  2. (****************************************************************************
  3.  *
  4.  *
  5.  * $Source: /dev/e/hm2/lib/se\RCS\SCSIDISK.M,v $
  6.  *
  7.  * $Revision: 1.3 $
  8.  *
  9.  * $Author: Steffen_Engel $
  10.  *
  11.  * $Date: 1996/02/14 00:00:26 $
  12.  *
  13.  * $State: Exp $
  14.  *
  15.  *****************************************************************************
  16.  * History:
  17.  *
  18.  * $Log: SCSIDISK.M,v $
  19.  * Revision 1.3  1996/02/14  00:00:26  Steffen_Engel
  20.  * Korrektur: cMaxBlockAdr muß 1FFFFF sein!
  21.  *
  22.  * Revision 1.2  1996/02/03  19:34:02  S_Engel
  23.  * Kleine Anpassungen
  24.  *
  25.  * Revision 1.1  1995/11/13  23:36:28  S_Engel
  26.  * Initial revision
  27.  *
  28.  *
  29.  *
  30.  ****************************************************************************)
  31.  
  32.  
  33. (* Systemabhängiges *)
  34. (* IMPLEMENTATION FÜR  >>> Hänisch-Modula-2 <<< *)
  35. (*                                              *)
  36. (* Durchgeführt von Steffen Engel               *)
  37. (*                                              *)
  38. (*$S-   Stack-Checks                            *)
  39. (*$I-   keine Variablen-Initialisierung         *)
  40. (*$V-   keine arithmetischen Kontrollen         *)
  41. (*$T-   kein Bereichstest                       *)
  42. (*$Y-   keine Laufzeittests auf RETURN und CASE *)
  43. (*                                              *)
  44. (*----------------------------------------------*)
  45.  
  46.  
  47.  
  48. IMPORT SYSTEM, System;
  49. FROM SYSTEM   (* Type  *) IMPORT BYTE, ADDRESS,
  50.               (* Proc  *) ADR, TSIZE;
  51.  
  52. FROM Portab IMPORT UChar, Char;
  53.  
  54. (* Standard HM2-Libs *)
  55.  
  56. (* Eigene Libs *)
  57.  
  58. (* Projektlibs *)
  59. IMPORT Scsi, ScsiIO;
  60. FROM Scsi IMPORT SetCmd6, SetCmd10, SetCmd12, SetCmd, BlockLen, MaxDmaLen;
  61.  
  62.  
  63. PROCEDURE ReassignBlocks(Buffer : ADDRESS; count : SHORTCARD) : BOOLEAN;
  64.  
  65. VAR
  66.   SCmd    : ScsiIO.tSCSICmd;
  67.   Cmd6    : Scsi.tCmd6;
  68.  
  69.   BEGIN
  70.     VOID(SetCmd6(Cmd6, 007H, 0, 0));
  71.     RETURN ScsiIO.Out(SetCmd(SCmd, Cmd6, Buffer, 4+count*4, ScsiIO.DefTimeout)) = 0;
  72.   END ReassignBlocks;
  73.  
  74.  
  75. PROCEDURE Read6(BlockAdr : LONGCARD;
  76.                TransferLen : SHORTCARD; Adr : ADDRESS) : BOOLEAN;
  77. VAR
  78.   Ok      : BOOLEAN;
  79.   MaxLen  : SHORTCARD;
  80.   SCmd    : ScsiIO.tSCSICmd;
  81.   Cmd6    : Scsi.tCmd6;
  82.  
  83. BEGIN
  84.   Ok:=TRUE;
  85.   MaxLen := MaxDmaLen DIV BlockLen;
  86.   IF MaxLen > 255
  87.     THEN
  88.       MaxLen := 255;
  89.     END;
  90.   WHILE Ok AND (TransferLen > MaxLen) DO
  91.     VOID(SetCmd6(Cmd6, 008H, BlockAdr, MaxLen));
  92.     Ok:=ScsiIO.In(SetCmd(SCmd, Cmd6, Adr, VAL(LONGCARD, MaxLen) * BlockLen, ScsiIO.DefTimeout)) = 0;
  93.     INC(BlockAdr, MaxLen);
  94.     DEC(TransferLen, MaxLen);
  95.     Adr := Adr + VAL(LONGCARD, MaxLen) * BlockLen;
  96.   END;
  97.   VOID(SetCmd6(Cmd6, 008H, BlockAdr, TransferLen));
  98.   RETURN Ok AND (ScsiIO.In(SetCmd(SCmd, Cmd6, Adr, VAL(LONGCARD, BlockLen) * VAL(LONGCARD, TransferLen), ScsiIO.DefTimeout)) = 0);
  99.  
  100. END Read6;
  101. PROCEDURE Read10(BlockAdr : LONGCARD;
  102.                TransferLen : SHORTCARD; Adr : ADDRESS) : BOOLEAN;
  103. VAR
  104.   Ok : BOOLEAN;
  105.   SCmd            : ScsiIO.tSCSICmd;
  106.   Cmd10    : Scsi.tCmd10;
  107.  
  108. BEGIN
  109.   Ok:=TRUE;
  110.   WHILE Ok AND (TransferLen > MaxDmaLen DIV BlockLen) DO
  111.     VOID(SetCmd10(Cmd10, 028H, BlockAdr, MaxDmaLen DIV BlockLen));
  112.     Ok := ScsiIO.In(SetCmd(SCmd, Cmd10, Adr, MaxDmaLen DIV BlockLen * BlockLen, 10 * 200)) = 0;
  113.     INC(BlockAdr, MaxDmaLen DIV BlockLen);
  114.     DEC(TransferLen, MaxDmaLen DIV BlockLen);
  115.     Adr := Adr + MaxDmaLen DIV BlockLen * BlockLen;
  116.   END;
  117.   VOID(SetCmd10(Cmd10, 028H, BlockAdr, TransferLen));
  118.   RETURN Ok AND(ScsiIO.In(SetCmd(SCmd, Cmd10, Adr, VAL(LONGCARD, BlockLen) * VAL(LONGCARD, TransferLen), ScsiIO.DefTimeout)) = 0);
  119. END Read10;
  120.  
  121. PROCEDURE Write6(BlockAdr : LONGCARD;
  122.                 TransferLen : SHORTCARD; Adr : ADDRESS) : BOOLEAN;
  123. VAR
  124.   Ok     : BOOLEAN;
  125.   MaxLen : SHORTCARD;
  126.   SCmd            : ScsiIO.tSCSICmd;
  127.   Cmd6    : Scsi.tCmd6;
  128.  
  129. BEGIN
  130.   Ok:=TRUE;
  131.   MaxLen := MaxDmaLen DIV BlockLen;
  132.   IF MaxLen > 255
  133.     THEN
  134.       MaxLen := 255;
  135.     END;
  136.   WHILE Ok AND (TransferLen > MaxLen) DO
  137.     VOID(SetCmd6(Cmd6, 00AH, BlockAdr, MaxLen));
  138.     Ok := ScsiIO.Out(SetCmd(SCmd, Cmd6, Adr, VAL(LONGCARD, MaxLen) * BlockLen, ScsiIO.DefTimeout)) = 0;
  139.     INC(BlockAdr, MaxLen);
  140.     DEC(TransferLen, MaxLen);
  141.     Adr := Adr + VAL(LONGCARD, MaxLen) * BlockLen;
  142.   END;
  143.   VOID(SetCmd6(Cmd6, 00AH,BlockAdr,TransferLen));
  144.   RETURN Ok AND (ScsiIO.Out(SetCmd(SCmd, Cmd6, Adr, BlockLen * VAL(LONGCARD, TransferLen), ScsiIO.DefTimeout)) = 0);
  145. END Write6;
  146. PROCEDURE Write10(BlockAdr : LONGCARD;
  147.                 TransferLen : SHORTCARD; Adr : ADDRESS) : BOOLEAN;
  148. VAR
  149.   Ok : BOOLEAN;
  150.   SCmd            : ScsiIO.tSCSICmd;
  151.   Cmd10    : Scsi.tCmd10;
  152.  
  153. BEGIN
  154.   Ok:=TRUE;
  155.   WHILE Ok AND (TransferLen>MaxDmaLen DIV BlockLen) DO
  156.     VOID(SetCmd10(Cmd10, 02AH,BlockAdr,MaxDmaLen DIV BlockLen));
  157.     Ok := ScsiIO.Out(SetCmd(SCmd, Cmd10, Adr, MaxDmaLen DIV BlockLen * BlockLen, 20*200)) = 0;
  158.     INC(BlockAdr,MaxDmaLen DIV BlockLen);
  159.     DEC(TransferLen, MaxDmaLen DIV BlockLen);
  160.     Adr := Adr + MaxDmaLen DIV BlockLen * BlockLen;
  161.   END;
  162.   VOID(SetCmd10(Cmd10, 02AH, BlockAdr, TransferLen));
  163.   RETURN Ok AND (ScsiIO.Out(SetCmd(SCmd, Cmd10, Adr, VAL(LONGCARD, BlockLen) * VAL(LONGCARD, TransferLen), 20*200)) = 0);
  164. END Write10;
  165.  
  166.  
  167. CONST
  168.     cMaxBlockAdr     =  001FFFFFH; (* Max. Blocknummer bei Read(6)/Write(6)  *)
  169.  
  170. PROCEDURE Read(BlockAdr : LONGCARD;
  171.                TransferLen : SHORTCARD; Adr : ADDRESS) : BOOLEAN;
  172.  
  173. BEGIN
  174.   IF (BlockAdr > cMaxBlockAdr)
  175.     THEN
  176.       RETURN Read10(BlockAdr, TransferLen, Adr);
  177.     ELSE
  178.       RETURN Read6(BlockAdr, TransferLen, Adr);
  179.     END;
  180. END Read;
  181.  
  182. PROCEDURE Write(BlockAdr : LONGCARD;
  183.                 TransferLen : SHORTCARD; Adr : ADDRESS) : BOOLEAN;
  184.  
  185. BEGIN
  186.   IF (BlockAdr > cMaxBlockAdr)
  187.     THEN
  188.       RETURN Write10(BlockAdr, TransferLen, Adr);
  189.     ELSE
  190.       RETURN Write6(BlockAdr, TransferLen, Adr);
  191.     END;
  192. END Write;
  193.  
  194. PROCEDURE StartStop(LoadEject, StartFlag : BOOLEAN) : BOOLEAN;
  195. VAR
  196.   SCmd            : ScsiIO.tSCSICmd;
  197.   Cmd6    : Scsi.tCmd6;
  198.  
  199. BEGIN
  200.   IF StartFlag THEN
  201.     VOID(SetCmd6(Cmd6, 01BH,0,1));
  202.   ELSE
  203.     VOID(SetCmd6(Cmd6, 01BH,0,0));
  204.   END; 
  205.   IF LoadEject
  206.     THEN
  207.       INCL(BYTESET(Cmd6.Len), 1);
  208.     END;
  209.   RETURN ScsiIO.In(SetCmd(SCmd, Cmd6, NIL, 0, 60*200)) = 0;
  210. END StartStop;
  211.  
  212. PROCEDURE Seek6(BlockAdr : LONGCARD) : BOOLEAN;
  213. VAR
  214.   SCmd            : ScsiIO.tSCSICmd;
  215.   Cmd6    : Scsi.tCmd6;
  216.  
  217.   BEGIN
  218.     VOID(SetCmd6(Cmd6, 00BH, BlockAdr, 0));
  219.     RETURN ScsiIO.In(SetCmd(SCmd, Cmd6, NIL, 0, ScsiIO.DefTimeout)) = 0;
  220.   END Seek6;
  221.  
  222. PROCEDURE Seek10(BlockAdr : LONGCARD) : BOOLEAN;
  223. VAR
  224.   SCmd            : ScsiIO.tSCSICmd;
  225.   Cmd10    : Scsi.tCmd10;
  226.  
  227.   BEGIN
  228.     VOID(SetCmd10(Cmd10, 02BH, BlockAdr, 0));
  229.     RETURN ScsiIO.In(SetCmd(SCmd, Cmd10, NIL, 0, ScsiIO.DefTimeout)) = 0;
  230.   END Seek10;
  231.  
  232. PROCEDURE Seek(BlockAdr : LONGCARD) : BOOLEAN;
  233.  
  234. BEGIN
  235.   IF BlockAdr > cMaxBlockAdr
  236.     THEN
  237.       RETURN Seek10(BlockAdr);
  238.     ELSE
  239.       RETURN Seek6(BlockAdr);
  240.     END;
  241. END Seek;
  242.  
  243. PROCEDURE Format() : BOOLEAN;
  244. VAR
  245.   SCmd            : ScsiIO.tSCSICmd;
  246.   Cmd6    : Scsi.tCmd6;
  247.  
  248.   BEGIN
  249.     VOID(SetCmd6(Cmd6, 004H,0,0));
  250.     RETURN ScsiIO.In(SetCmd(SCmd, Cmd6, NIL, 0, 24*60*60*200)) = 0;
  251.   END Format;
  252.  
  253.  
  254. PROCEDURE ReadCapacity(PMI : BOOLEAN; VAR BlockAdr, BlockLen : LONGCARD) : BOOLEAN;
  255. VAR
  256.   Data : ARRAY[0..1] OF LONGCARD;
  257.   Ok : BOOLEAN;
  258.   SCmd            : ScsiIO.tSCSICmd;
  259.   Cmd10    : Scsi.tCmd10;
  260.  
  261.   BEGIN
  262.     VOID(SetCmd10(Cmd10, 025H, BlockAdr, 0));
  263.  
  264.     IF PMI
  265.       THEN
  266.         Cmd10.LenLow := 1;
  267.       END;
  268.  
  269.     (* und rufen *)
  270.     Ok := ScsiIO.In(SetCmd(SCmd, Cmd10, ADR(Data), SIZE(Data), ScsiIO.DefTimeout)) = 0;
  271. (*    Ok := ScsiIO.SendCmdDataIn(Cmd10, 10, ADR(Data), SIZE(Data));*)
  272.  
  273.     (* und Antwort, bitte *)
  274.     IF Ok
  275.       THEN
  276.         BlockAdr := Data[0];
  277.         BlockLen := Data[1];
  278.       END;
  279.  
  280.     RETURN Ok;
  281.  
  282.   END ReadCapacity;
  283.  
  284.  
  285. PROCEDURE ReadDefectData(Buffer       : ADDRESS;
  286.                          Plist, Glist : BOOLEAN;
  287.                          Format       : SHORTCARD;
  288.                          Len          : SHORTCARD) : BOOLEAN;
  289. VAR
  290.   SCmd    : ScsiIO.tSCSICmd;
  291.   Cmd10   : Scsi.tCmd10;
  292.  
  293.   BEGIN
  294.     VOID(SetCmd10(Cmd10, 037H,
  295.                   (ORD(Plist) * 10H
  296.                     + ORD(Glist) * 08H
  297.                     + VAL(LONGCARD, Format)) * 01000000H,
  298.                   Len));
  299.  
  300.     RETURN ScsiIO.In(SetCmd(SCmd, Cmd10,
  301.                             Buffer, Len,
  302.                             ScsiIO.DefTimeout)) = 0;
  303.  
  304.  
  305.   END ReadDefectData;
  306.  
  307.  
  308. END ScsiDisk.
  309.